/* 
 scanMusicFolder.ts
 用于扫描音乐文件夹，提取音乐元数据和歌词，生成音乐列表文件
 music-metadata 是一个功能强大的Node.js库，用于从各种音频文件格式中读取元数据。它支持广泛的音频格式
*/
import * as fs from 'node:fs'
import * as path from 'node:path'
import { parseFile, parseBuffer, ILyricsTag } from 'music-metadata'
import { v4 as uuidv4 } from 'uuid'

// 配置输出路径
let MUSIC_DIR = ''
let COVERS_DIR = ''
let LYRICS_DIR = ''
let METADATA_FILE = ''
let DEFAULT_COVER = 'default.jpg' // 默认封面图
// 资源存储根路径
// let storeBasePath = `app:///E:/5Project/PCByElectronProject/electron-app/src/main/localMusicService/music/`
let storeBasePath = `http://127.0.0.1:9000/static/`

async function scanMusicFolder({ folderPath, outputPath }) {
  // 确保目录存在,如果不存在则创建
  async function ensureDir(dir) {
    if (!fs.existsSync(dir)) {
      await fs.mkdirSync(dir, { recursive: true })
    }
  }

  // 清理文件名（去除扩展名，用于匹配封面和歌词）
  function getBaseName(filePath) {
    return path.basename(filePath, path.extname(filePath))
  }
  const aa = path.join(__dirname, outputPath)
  console.log('aa', aa)

  // 检查是否存在歌词文件
  async function findLyrics(baseName, folderPath, item) {
    const extensions = ['.lrc', '.txt']
    for (const ext of extensions) {
      const lyricPath = path.join(folderPath, baseName + ext)
      if (fs.existsSync(lyricPath)) {
        // 复制歌词文件
        fs.copyFileSync(lyricPath, LYRICS_DIR + '/' + baseName + ext)
        return path.basename(lyricPath)
      }
    }
    return null
  }
  // 提取并保存封面图
  async function extractCover(metadata, coverFileName) {
    if (metadata.common.picture && metadata.common.picture.length > 0) {
      const picture = metadata.common.picture[0]
      const coverPath = path.join(COVERS_DIR, coverFileName)

      try {
        fs.writeFileSync(coverPath, picture.data)
        // console.log(`✅ 封面已保存: ${coverPath}`)
        return path.basename(coverPath)
      } catch (err) {
        console.error(`❌ 保存封面失败: ${coverPath}`, err)
        return DEFAULT_COVER
      }
    }
    return DEFAULT_COVER // 无嵌入封面时返回默认
  }
  // 配置输出路径
  MUSIC_DIR = `${outputPath}/song`
  COVERS_DIR = `${outputPath}/covers`
  LYRICS_DIR = `${outputPath}/lyrics`
  METADATA_FILE = `${outputPath}/metadata.json`
  DEFAULT_COVER = `/resources/logo.png` // 默认封面图

  const results: any = []

  async function scan(dir) {
    // 确保输出音乐文件夹存在
    await ensureDir(MUSIC_DIR)
    // 确保输出封面文件夹存在
    await ensureDir(COVERS_DIR)
    // 确保输出歌词文件夹存在
    await ensureDir(LYRICS_DIR)
    // 读取目标文件夹
    /* const files = fs.readdirSync(dir).filter((file) => {
      return /\.(mp3|flac|wav|m4a|aac|ogg)$/i.test(file)
    }) */
    const dataList = await fs.promises.readdir(dir, { withFileTypes: true })
    const files = dataList.filter((file) => {
      return /\.(mp3|flac|wav|m4a|aac|ogg)$/i.test(file.name)
    })

    if (files.length === 0) {
      console.log(`⚠️ 未在 ${folderPath} 目录中找到音乐文件`)
      return
    }

    for (const item of files) {
      const fullPath = path.join(dir, item.name)
      const baseName = getBaseName(item.name)
      const coverFileName = `${baseName}.jpg` // 统一保存为 .jpg
      // console.log('----->>>>', fullPath, item)

      if (item.isDirectory()) {
        await scan(fullPath) // 递归扫描子目录
      } else {
        try {
          // 读取音频元信息
          const metadata = await parseFile(fullPath)

          // 1. ✅ 复制音乐文件
          fs.copyFileSync(fullPath, MUSIC_DIR + '/' + item.name)

          // 2. ✅ 提取并保存封面图
          const coverFile = await extractCover(metadata, coverFileName)
          const coverPath = path.join('covers', coverFile)

          // 3. ✅ 查找歌词并复制
          const lyricFile = await findLyrics(baseName, folderPath, item)
          const lyricPath = lyricFile ? path.join('lyrics', lyricFile) : null

          // 构建歌曲对象
          results.push({
            id: uuidv4(),
            filename: item.name,
            // 歌曲标题
            title: metadata.common.title || baseName,
            // 艺术家/演唱者
            artist: metadata.common.artist || '未知艺术家',
            // 所属专辑
            album: metadata.common.album || '未知专辑',
            // 时长（秒）
            duration: Math.round((metadata.format.duration || 0) * 100) / 100,
            // 音乐流派
            genre: metadata.common.genre || [],
            // 发行年份
            year: metadata.common.year || null,
            // 音频格式
            format: metadata.format.codec || path.extname(item.name).slice(1),
            // 歌曲路径
            // pathSong: path.join('song', item.name).replace(/\\/g, '/'), // 统一路径分隔符
            // 歌曲路径
            pathSong: storeBasePath + path.join('song', item.name).replace(/\\/g, '/'), // 统一路径分隔符

            // 封面路径
            // pathCover: coverPath.replace(/\\/g, '/'), // 统一路径分隔符
            pathCover: storeBasePath + coverPath.replace(/\\/g, '/'), // 统一路径分隔符
            // 歌词路径
            // pathLyrics: lyricPath?.replace(/\\/g, '/'), // 统一路径分隔符+
            // 歌词路径
            pathLyrics: storeBasePath + lyricPath?.replace(/\\/g, '/'), // 统一路径分隔符+
            // 添加时间
            addedAt: new Date().toISOString()
          })
        } catch (error) {
          console.error(`Error reading ${fullPath}:`, error)
        }
      }
    }
  }

  await scan(folderPath)

  // 保存元数据到 JSON 文件
  try {
    fs.writeFileSync(METADATA_FILE, JSON.stringify({ results }, null, 2), 'utf-8')
    console.log(`\n🎉 元数据已生成: ${METADATA_FILE}`)
    console.log(`📊 共扫描 ${results.length} 首音乐`)
  } catch (err) {
    console.error('❌ 保存 metadata.json 失败:', err)
  }
  return results
}

async function getMusicList(targetPath) {
  try {
    METADATA_FILE = `${targetPath}/metadata.json`
    const data = await fs.promises.readFile(METADATA_FILE, 'utf-8')
    const metadata = JSON.parse(data)
    return metadata.results
  } catch (error: any) {
    if (error.code === 'ENOENT') {
      // 文件不存在
      return []
    } else {
      console.error(`获取 JSON 缓存失败:`, error.message)
      throw error
    }
  }
}

export { scanMusicFolder, getMusicList }
